package cn.jingyuan.bee.utils.lang;

import cn.jingyuan.bee.utils.HashUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * 一致性 Hash 算法
 * 算法详解：http://blog.csdn.net/sparkliang/article/details/5279393
 * 算法实现：https://weblogs.java.net/blog/2007/11/27/consistent-hashing
 *
 * @param <T> 节点类型
 */
public class ConsistentHash<T> implements Serializable {

    /** 复制的节点个数 */
    private final int numberOfReplicas;

    /** 一致性 Hash 环 */
    private final SortedMap<Integer, T> circle = new TreeMap<Integer, T>();

    /** Hash 计算对象，用于自定义 hash 算法 */
    HashFunc hashFunc;

    /**
     * 构造，使用 Java 默认的 Hash 算法
     *
     * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
     * @param nodes 节点对象
     */
    public ConsistentHash(int numberOfReplicas, Collection<T> nodes) {
        this.numberOfReplicas = numberOfReplicas;
        this.hashFunc = new HashFunc() {

            @Override
            public Integer hash(Object key) {
                // 默认使用 FNV1hash 算法
                return HashUtils.fnvHash(key.toString());
            }
        };
        // 初始化节点
        for (T node : nodes) {
            add(node);
        }
    }

    /**
     * 构造
     *
     * @param hashFunc hash 算法对象
     * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
     * @param nodes 节点对象
     */
    public ConsistentHash(HashFunc hashFunc, int numberOfReplicas, Collection<T> nodes) {
        this.numberOfReplicas = numberOfReplicas;
        this.hashFunc = hashFunc;
        // 初始化节点
        for (T node : nodes) {
            add(node);
        }
    }

    /**
     * 增加节点<br>
     * 每增加一个节点，就会在闭环上增加给定复制节点数<br>
     * 例如复制节点数是 2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一 Node
     * 由于 hash 算法会调用 node 的 toString 方法，故按照 toString 去重
     *
     * @param node 节点对象
     */
    public void add(T node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            circle.put(hashFunc.hash(node.toString() + i), node);
        }
    }

    /**
     * 移除节点的同时移除相应的虚拟节点
     *
     * @param node 节点对象
     */
    public void remove(T node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            circle.remove(hashFunc.hash(node.toString() + i));
        }
    }

    /**
     * 获得一个最近的顺时针节点
     *
     * @param key 为给定键取 Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点
     *
     * @return 节点对象
     */
    public T get(Object key) {
        if (circle.isEmpty()) {
            return null;
        }
        int hash = hashFunc.hash(key);
        if (!circle.containsKey(hash)) {
            // 返回此映射的部分视图，其键大于等于 hash
            SortedMap<Integer, T> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        // 正好命中
        return circle.get(hash);
    }

    /**
     * Hash 算法对象，用于自定义 hash 算法
     */
    public interface HashFunc {

        Integer hash(Object key);

    }

}